// pages/biz/index.js
const BizService = require('../../services/biz');
const locationUtil = require('../../utils/location.js');

Page({
  /**
   * 页面的初始数据
   */
  data: {
    bizList: [], // 商家列表
    allBizList: [], // 存储所有商家数据（用于距离排序）
    total: 0, // 总数
    page: 1, // 当前页码
    pageSize: 10, // 每页数量
    hasMore: true, // 是否有更多数据
    loading: false, // 是否正在加载
    refreshing: false, // 是否正在刷新
    sortType: 'default', // 排序类型：default-默认, distance-距离, rating-好评, star-星级
    sortTypes: [
      { key: 'default', name: '默认' },
      { key: 'distance', name: '距离' },
      { key: 'rating', name: '好评' },
      { key: 'star', name: '星级' }
    ],
    userLocation: null, // 用户位置信息
    locationPermission: false, // 位置权限状态
    allDataLoaded: false // 是否已加载所有数据
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    this.getUserLocation();
    this.loadBizList();
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 获取用户位置
   */
  async getUserLocation() {
    try {
      // 检查位置权限
      const setting = await wx.getSetting();
      if (setting.authSetting['scope.userLocation'] === false) {
        this.setData({
          locationPermission: false
        });
        return;
      }

      // 获取位置信息
      const location = await locationUtil.getUserLocation();
      if (location.success) {
        this.setData({
          userLocation: location,
          locationPermission: true
        });
        console.log('获取位置成功:', location);
        
        // 获取位置成功后，重新加载商家列表以计算距离
        this.reloadBizListWithLocation();
      }
    } catch (error) {
      console.error('获取位置失败:', error);
      this.setData({
        locationPermission: false
      });
    }
  },

  /**
   * 重新加载商家列表（获取位置后调用）
   */
  reloadBizListWithLocation() {
    // 如果当前是距离排序，重新加载所有数据并排序
    if (this.data.sortType === 'distance') {
      this.setData({
        allDataLoaded: false,
        allBizList: [],
        page: 1
      }, () => {
        this.loadAllBizList();
      });
    } else {
      // 其他排序类型，只重新计算距离显示，不排序
      if (this.data.bizList.length > 0) {
        const bizListWithDistance = locationUtil.addDistanceToBizList(this.data.bizList, this.data.userLocation);
        this.setData({
          bizList: bizListWithDistance
        });
      }
    }
  },

  /**
   * 请求位置权限
   */
  requestLocationPermission() {
    wx.showModal({
      title: '位置权限',
      content: '需要获取您的位置信息来显示附近的商家，是否授权？',
      success: (res) => {
        if (res.confirm) {
          wx.openSetting({
            success: (settingRes) => {
              if (settingRes.authSetting['scope.userLocation']) {
                // 用户授权后，立即获取位置并重新加载数据
                this.getUserLocation();
              }
            }
          });
        }
      }
    });
  },

  /**
   * 加载所有商家数据（用于距离排序）
   */
  async loadAllBizList() {
    if (this.data.allDataLoaded) {
      return;
    }

    try {
      this.setData({ loading: true });

      // 加载所有商家数据（不分页）
      const result = await BizService.getBizList({
        page: 1,
        pageSize: 1000, // 设置一个较大的值来获取所有数据
        sortType: this.data.sortType,
        showLoading: false
      });

      if (result.success) {
        let allBizList = result.data || [];
        
        // 如果有用户位置信息，计算距离
        if (this.data.userLocation) {
          allBizList = locationUtil.addDistanceToBizList(allBizList, this.data.userLocation);
          
          // 只有在"距离"排序时才按距离排序
          if (this.data.sortType === 'distance') {
            allBizList = locationUtil.sortBizListByDistance(allBizList);
          }
        }

        this.setData({
          allBizList: allBizList,
          allDataLoaded: true,
          loading: false
        });

        // 更新当前页显示的数据
        this.updateCurrentPageData();
      } else {
        this.setData({ loading: false });
      }
    } catch (error) {
      console.error('加载所有商家数据失败:', error);
      this.setData({ loading: false });
    }
  },

  /**
   * 更新当前页显示的数据
   */
  updateCurrentPageData() {
    const startIndex = (this.data.page - 1) * this.data.pageSize;
    const endIndex = startIndex + this.data.pageSize;
    const currentPageData = this.data.allBizList.slice(startIndex, endIndex);
    
    this.setData({
      bizList: currentPageData,
      hasMore: endIndex < this.data.allBizList.length
    });
  },

  /**
   * 加载商家列表
   */
  async loadBizList(isRefresh = false) {
    // 只有在"距离"排序时才需要加载所有数据并排序
    if (this.data.sortType === 'distance') {
      if (isRefresh) {
        this.setData({
          page: 1,
          allDataLoaded: false,
          allBizList: []
        });
      }
      await this.loadAllBizList();
    } else {
      // 其他排序类型使用分页加载，只显示距离不排序
      await this.loadBizListByPage(isRefresh);
    }
  },

  /**
   * 分页加载商家列表
   */
  async loadBizListByPage(isRefresh = false) {
    if (this.data.loading) {
      return;
    }

    this.setData({
      loading: true
    });

    try {
      const params = {
        page: isRefresh ? 1 : this.data.page,
        pageSize: this.data.pageSize,
        sortType: this.data.sortType,
        showLoading: false
      };

      const result = await BizService.getBizList(params);

      if (result.success) {
        let newList = isRefresh ? (result.data || []) : [...this.data.bizList, ...(result.data || [])];
        
        // 如果有用户位置信息，计算距离
        if (this.data.userLocation) {
          newList = locationUtil.addDistanceToBizList(newList, this.data.userLocation);
        }
        
        const hasMore = (result.data || []).length >= this.data.pageSize;
        
        this.setData({
          bizList: newList,
          total: result.total || 0,
          page: isRefresh ? 1 : this.data.page,
          hasMore: hasMore,
          loading: false,
          refreshing: false
        });
      } else {
        wx.showToast({
          title: result.message || '加载失败',
          icon: 'none'
        });
        this.setData({
          loading: false,
          refreshing: false
        });
      }
    } catch (error) {
      console.error('加载商家列表失败:', error);
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      });
      this.setData({
        loading: false,
        refreshing: false
      });
    }
  },

  /**
   * 切换排序类型
   */
  onSortTypeChange(e) {
    const sortType = e.currentTarget.dataset.type;
    if (sortType === this.data.sortType) {
      return;
    }

    // 如果选择距离排序但没有位置权限，提示用户授权
    if (sortType === 'distance' && !this.data.locationPermission) {
      this.requestLocationPermission();
      return;
    }

    this.setData({
      sortType: sortType,
      page: 1,
      bizList: [],
      hasMore: true,
      allDataLoaded: false,
      allBizList: []
    }, () => {
      this.loadBizList(true);
    });
  },

  /**
   * 跳转到商家详情
   */
  toBizDetail(e) {
    const id = e.currentTarget.dataset.id;
    if (id) {
      wx.navigateTo({
        url: `/pages/biz/detail?id=${id}`
      });
    }
  },

  /**
   * 跳转到商品详情
   */
  toGoodsDetail(e) {
    const id = e.currentTarget.dataset.id;
    if (id) {
      wx.navigateTo({
        url: `/pages/biz/goods?id=${id}`
      });
    }
  },

  /**
   * 评分变化事件
   */
  onChange(e) {
    // 评分变化处理
    console.log('评分变化:', e.detail);
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    this.setData({
      refreshing: true,
      page: 1,
      allDataLoaded: false,
      allBizList: []
    });
    this.loadBizList(true).then(() => {
      wx.stopPullDownRefresh();
    });
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {
    if (this.data.hasMore && !this.data.loading) {
      if (this.data.sortType === 'distance') {
        // 距离排序时，从已加载的数据中获取下一页
        this.setData({
          page: this.data.page + 1
        }, () => {
          this.updateCurrentPageData();
        });
      } else {
        // 其他排序类型，请求下一页数据
        this.setData({
          page: this.data.page + 1
        }, () => {
          this.loadBizListByPage();
        });
      }
    }
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  }
})